using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("ChoiceCardMgr")]
	public class ChoiceCardMgr : MonoBehaviour
	{
		[Attribute38("ChoiceCardMgr.CommonData")]
		public class CommonData : MonoClass
		{
			public float m_FriendlyCardWidth => method_2<float>("m_FriendlyCardWidth");

			public float m_OpponentCardWidth => method_2<float>("m_OpponentCardWidth");

			public int m_MaxCardsBeforeAdjusting => method_2<int>("m_MaxCardsBeforeAdjusting");

			public CommonData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CommonData(IntPtr address)
				: this(address, "CommonData")
			{
			}
		}

		[Attribute38("ChoiceCardMgr.ChoiceData")]
		public class ChoiceData : MonoClass
		{
			public string m_FriendlyBoneName => method_4("m_FriendlyBoneName");

			public string m_OpponentBoneName => method_4("m_OpponentBoneName");

			public string m_BannerBoneName => method_4("m_BannerBoneName");

			public string m_ButtonBoneName => method_4("m_ButtonBoneName");

			public float m_MinShowTime => method_2<float>("m_MinShowTime");

			public Banner m_BannerPrefab => method_3<Banner>("m_BannerPrefab");

			public string m_ButtonPrefab => method_4("m_ButtonPrefab");

			public float m_CardShowTime => method_2<float>("m_CardShowTime");

			public float m_CardHideTime => method_2<float>("m_CardHideTime");

			public float m_UiShowTime => method_2<float>("m_UiShowTime");

			public float m_HorizontalPadding => method_2<float>("m_HorizontalPadding");

			public ChoiceData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ChoiceData(IntPtr address)
				: this(address, "ChoiceData")
			{
			}
		}

		[Attribute38("ChoiceCardMgr.SubOptionData")]
		public class SubOptionData : MonoClass
		{
			public string m_BoneName => method_4("m_BoneName");

			public float m_AdjacentCardXOffset => method_2<float>("m_AdjacentCardXOffset");

			public float m_PhoneMaxAdjacentCardXOffset => method_2<float>("m_PhoneMaxAdjacentCardXOffset");

			public float m_MinionParentXOffset => method_2<float>("m_MinionParentXOffset");

			public float m_CardShowTime => method_2<float>("m_CardShowTime");

			public SubOptionData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public SubOptionData(IntPtr address)
				: this(address, "SubOptionData")
			{
			}
		}

		[Attribute38("ChoiceCardMgr.ChoiceEffectData")]
		public class ChoiceEffectData : MonoClass
		{
			public bool m_AlwaysPlayEffect => method_2<bool>("m_AlwaysPlayEffect");

			public bool m_PlayOncePerCard => method_2<bool>("m_PlayOncePerCard");

			public Spell m_Spell => method_3<Spell>("m_Spell");

			public ChoiceEffectData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ChoiceEffectData(IntPtr address)
				: this(address, "ChoiceEffectData")
			{
			}
		}

		[Attribute38("ChoiceCardMgr.SubOptionState")]
		public class SubOptionState : MonoClass
		{
			public List<Card> m_cards => method_3<Class271<Card>>("m_cards")?.method_25();

			public Card m_parentCard => method_3<Card>("m_parentCard");

			public SubOptionState(IntPtr address, string className)
				: base(address, className)
			{
			}

			public SubOptionState(IntPtr address)
				: this(address, "SubOptionState")
			{
			}
		}

		public struct TransformData
		{
		}

		[Attribute38("ChoiceCardMgr.ChoiceState")]
		public class ChoiceState : MonoClass
		{
			public int m_choiceID => method_2<int>("m_choiceID");

			public bool m_isFriendly => method_2<bool>("m_isFriendly");

			public List<Card> m_cards => method_3<Class271<Card>>("m_cards")?.method_25();

			public List<TransformData> m_cardTransforms => method_3<Class270<TransformData>>("m_cardTransforms")?.method_25();

			public bool m_waitingToStart => method_2<bool>("m_waitingToStart");

			public bool m_hasBeenRevealed => method_2<bool>("m_hasBeenRevealed");

			public bool m_hasBeenConcealed => method_2<bool>("m_hasBeenConcealed");

			public bool m_hideChosen => method_2<bool>("m_hideChosen");

			public PowerTaskList m_preTaskList => method_3<PowerTaskList>("m_preTaskList");

			public int m_sourceEntityId => method_2<int>("m_sourceEntityId");

			public List<Entity> m_chosenEntities => method_3<Class271<Entity>>("m_chosenEntities")?.method_25();

			public ChoiceState(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ChoiceState(IntPtr address)
				: this(address, "ChoiceState")
			{
			}
		}

		public CommonData m_CommonData => method_3<CommonData>("m_CommonData");

		public ChoiceData m_ChoiceData => method_3<ChoiceData>("m_ChoiceData");

		public SubOptionData m_SubOptionData => method_3<SubOptionData>("m_SubOptionData");

		public ChoiceEffectData m_DiscoverChoiceEffectData => method_3<ChoiceEffectData>("m_DiscoverChoiceEffectData");

		public ChoiceEffectData m_AdaptChoiceEffectData => method_3<ChoiceEffectData>("m_AdaptChoiceEffectData");

		public static Vector3 INVISIBLE_SCALE => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "ChoiceCardMgr", "INVISIBLE_SCALE");

		public SubOptionState m_subOptionState => method_3<SubOptionState>("m_subOptionState");

		public Banner m_choiceBanner => method_3<Banner>("m_choiceBanner");

		public NormalButton m_choiceButton => method_3<NormalButton>("m_choiceButton");

		public bool m_friendlyChoicesShown => method_2<bool>("m_friendlyChoicesShown");

		public bool m_restoreEnlargedHand => method_2<bool>("m_restoreEnlargedHand");

		public ChoiceState m_lastShownChoiceState => method_3<ChoiceState>("m_lastShownChoiceState");

		public ChoiceCardMgr(IntPtr address, string className)
			: base(address, className)
		{
		}

		public ChoiceCardMgr(IntPtr address)
			: this(address, "ChoiceCardMgr")
		{
		}

		public static ChoiceCardMgr Get()
		{
			return MonoClass.smethod_15<ChoiceCardMgr>(TritonHs.MainAssemblyPath, "", "ChoiceCardMgr", "Get", Array.Empty<object>());
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Start()
		{
			method_8("Start");
		}

		public List<Card> GetFriendlyCards()
		{
			return method_14<Class271<Card>>("GetFriendlyCards", Array.Empty<object>())?.method_25();
		}

		public bool IsShown()
		{
			return method_11<bool>("IsShown", Array.Empty<object>());
		}

		public bool IsFriendlyShown()
		{
			return method_11<bool>("IsFriendlyShown", Array.Empty<object>());
		}

		public bool HasSubOption()
		{
			return method_11<bool>("HasSubOption", Array.Empty<object>());
		}

		public Card GetSubOptionParentCard()
		{
			return method_14<Card>("GetSubOptionParentCard", Array.Empty<object>());
		}

		public void ClearSubOptions()
		{
			method_8("ClearSubOptions");
		}

		public void ShowSubOptions(Card parentCard)
		{
			method_9("ShowSubOptions", new Class276.Enum20[1] { Class276.Enum20.Class }, parentCard);
		}

		public bool IsWaitingToShowSubOptions()
		{
			return method_11<bool>("IsWaitingToShowSubOptions", Array.Empty<object>());
		}

		public void CancelSubOptions()
		{
			method_8("CancelSubOptions");
		}

		public void OnSubOptionClicked(Entity chosenEntity)
		{
			method_8("OnSubOptionClicked", chosenEntity);
		}

		public bool HasChoices()
		{
			return method_10<bool>("HasChoices", new Class276.Enum20[0], Array.Empty<object>());
		}

		public bool HasChoices(int playerId)
		{
			return method_10<bool>("HasChoices", new Class276.Enum20[1] { Class276.Enum20.I4 }, new object[1] { playerId });
		}

		public bool HasFriendlyChoices()
		{
			return method_11<bool>("HasFriendlyChoices", Array.Empty<object>());
		}

		public PowerTaskList GetPreChoiceTaskList(int playerId)
		{
			return method_14<PowerTaskList>("GetPreChoiceTaskList", new object[1] { playerId });
		}

		public PowerTaskList GetFriendlyPreChoiceTaskList()
		{
			return method_14<PowerTaskList>("GetFriendlyPreChoiceTaskList", Array.Empty<object>());
		}

		public bool IsWaitingToStartChoices(int playerId)
		{
			return method_11<bool>("IsWaitingToStartChoices", new object[1] { playerId });
		}

		public bool IsFriendlyWaitingToStartChoices()
		{
			return method_11<bool>("IsFriendlyWaitingToStartChoices", Array.Empty<object>());
		}

		public NormalButton GetChoiceButton()
		{
			return method_14<NormalButton>("GetChoiceButton", Array.Empty<object>());
		}

		public void OnEntityChoicesReceived(Network.EntityChoices choices, PowerTaskList preChoiceTaskList, object userData)
		{
			method_8("OnEntityChoicesReceived", choices, preChoiceTaskList, userData);
		}

		public bool OnEntitiesChosenReceived(Network.EntitiesChosen chosen, object userData)
		{
			return method_11<bool>("OnEntitiesChosenReceived", new object[2] { chosen, userData });
		}

		public void OnGameOver(TAG_PLAYSTATE playState, object userData)
		{
			method_8("OnGameOver", playState, userData);
		}

		public bool IsChoiceCardReady(Card card)
		{
			return method_11<bool>("IsChoiceCardReady", new object[1] { card });
		}

		public void PopulateTransformDatas(ChoiceState state)
		{
			method_8("PopulateTransformDatas", state);
		}

		public float GetScaleForCardCount(int cardCount)
		{
			return method_11<float>("GetScaleForCardCount", new object[1] { cardCount });
		}

		public float GetPaddingForCardCount(int cardCount)
		{
			return method_11<float>("GetPaddingForCardCount", new object[1] { cardCount });
		}

		public void StartChoices(ChoiceState state)
		{
			method_8("StartChoices", state);
		}

		public void RevealChoiceCards(ChoiceState state)
		{
			method_8("RevealChoiceCards", state);
		}

		public void DefaultRevealChoiceCards(ChoiceState state)
		{
			method_8("DefaultRevealChoiceCards", state);
		}

		public void ShowChoiceCards(ChoiceState state, bool friendly)
		{
			method_8("ShowChoiceCards", state, friendly);
		}

		public void PlayChoiceEffects(ChoiceState state, bool friendly)
		{
			method_8("PlayChoiceEffects", state, friendly);
		}

		public ChoiceEffectData GetChoiceEffectDataForCard(Card sourceCard)
		{
			return method_14<ChoiceEffectData>("GetChoiceEffectDataForCard", new object[1] { sourceCard });
		}

		public void ResolveConflictBetweenLocalChoiceAndServerPacket(ChoiceState choiceState, Network.EntitiesChosen chosen)
		{
			method_8("ResolveConflictBetweenLocalChoiceAndServerPacket", choiceState, chosen);
		}

		public void ConcealChoicesFromPacket(int playerId, ChoiceState choiceState, Network.EntitiesChosen chosen)
		{
			method_8("ConcealChoicesFromPacket", playerId, choiceState, chosen);
		}

		public void DefaultConcealChoicesFromPacket(int playerId, ChoiceState choiceState, Network.EntitiesChosen chosen)
		{
			method_8("DefaultConcealChoicesFromPacket", playerId, choiceState, chosen);
		}

		public void ConcealChoicesFromInput(int playerId, ChoiceState choiceState)
		{
			method_8("ConcealChoicesFromInput", playerId, choiceState);
		}

		public void OnFinishedConcealChoices(int playerId)
		{
			method_8("OnFinishedConcealChoices", playerId);
		}

		public void HideChoiceCards(ChoiceState state)
		{
			method_8("HideChoiceCards", state);
		}

		public void HideChoiceCard(Card card)
		{
			method_8("HideChoiceCard", card);
		}

		public void HideChoiceUI()
		{
			method_8("HideChoiceUI");
		}

		public void HideChoiceBanner()
		{
			method_8("HideChoiceBanner");
		}

		public void ShowChoiceButton()
		{
			method_8("ShowChoiceButton");
		}

		public void HideChoiceButton()
		{
			method_8("HideChoiceButton");
		}

		public void HideEnlargedHand()
		{
			method_8("HideEnlargedHand");
		}

		public void RestoreEnlargedHand()
		{
			method_8("RestoreEnlargedHand");
		}

		public void ChoiceButton_OnPress(UIEvent e)
		{
			method_8("ChoiceButton_OnPress", e);
		}

		public void ChoiceButton_OnRelease(UIEvent e)
		{
			method_8("ChoiceButton_OnRelease", e);
		}

		public void CancelChoices()
		{
			method_8("CancelChoices");
		}

		public void ShowSubOptions()
		{
			method_9("ShowSubOptions", new Class276.Enum20[0]);
		}

		public void HideSubOptions(Entity chosenEntity)
		{
			method_8("HideSubOptions", chosenEntity);
		}

		public bool IsEntityReady(Entity entity)
		{
			return method_11<bool>("IsEntityReady", new object[1] { entity });
		}

		public bool IsCardReady(Card card)
		{
			return method_11<bool>("IsCardReady", new object[1] { card });
		}

		public bool IsCardActorReady(Card card)
		{
			return method_11<bool>("IsCardActorReady", new object[1] { card });
		}

		public Spell GetCustomChoiceRevealSpell(ChoiceState choiceState)
		{
			return method_14<Spell>("GetCustomChoiceRevealSpell", new object[1] { choiceState });
		}

		public Spell GetCustomChoiceConcealSpell(ChoiceState choiceState)
		{
			return method_14<Spell>("GetCustomChoiceConcealSpell", new object[1] { choiceState });
		}

		public void RevealChoiceCardsUsingCustomSpell(Spell customChoiceRevealSpell, ChoiceState state)
		{
			method_8("RevealChoiceCardsUsingCustomSpell", customChoiceRevealSpell, state);
		}

		public void OnCustomChoiceRevealSpellFinished(Spell spell, object userData)
		{
			method_8("OnCustomChoiceRevealSpellFinished", spell, userData);
		}

		public void ConcealChoiceCardsUsingCustomSpell(Spell customChoiceConcealSpell, ChoiceState choiceState, Network.EntitiesChosen chosen)
		{
			method_8("ConcealChoiceCardsUsingCustomSpell", customChoiceConcealSpell, choiceState, chosen);
		}

		public void OnCustomChoiceConcealSpellFinished(Spell spell, object userData)
		{
			method_8("OnCustomChoiceConcealSpellFinished", spell, userData);
		}
	}
}
